home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2002 #11 / Amiga Plus CD - 2002 - No. 11.iso / Tools / Development / libogg / libvorbis-1.0rc3 / lib / mapping0.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-10-27  |  19.9 KB  |  702 lines
  1. /********************************************************************
  2.  *                                                                  *
  3.  * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
  4.  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
  5.  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
  6.  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
  7.  *                                                                  *
  8.  * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2001             *
  9.  * by the XIPHOPHORUS Company http://www.xiph.org/                  *
  10.  *                                                                  *
  11.  ********************************************************************
  12.  
  13.  function: channel mapping 0 implementation
  14.  last mod: $Id: mapping0.c,v 1.43 2001/12/20 01:00:27 segher Exp $
  15.  
  16.  ********************************************************************/
  17.  
  18. #include <stdlib.h>
  19. #include <stdio.h>
  20. #include <string.h>
  21. #include <math.h>
  22. #include <ogg/ogg.h>
  23. #include "vorbis/codec.h"
  24. #include "codec_internal.h"
  25. #include "codebook.h"
  26. #include "registry.h"
  27. #include "psy.h"
  28. #include "misc.h"
  29.  
  30. /* simplistic, wasteful way of doing this (unique lookup for each
  31.    mode/submapping); there should be a central repository for
  32.    identical lookups.  That will require minor work, so I'm putting it
  33.    off as low priority.
  34.  
  35.    Why a lookup for each backend in a given mode?  Because the
  36.    blocksize is set by the mode, and low backend lookups may require
  37.    parameters from other areas of the mode/mapping */
  38.  
  39. extern int analysis_noisy;
  40.  
  41. typedef struct {
  42.   drft_lookup fft_look;
  43.   vorbis_info_mode *mode;
  44.   vorbis_info_mapping0 *map;
  45.  
  46.   vorbis_look_time **time_look;
  47.   vorbis_look_floor **floor_look;
  48.  
  49.   vorbis_look_residue **residue_look;
  50.   vorbis_look_psy *psy_look[2];
  51.  
  52.   vorbis_func_time **time_func;
  53.   vorbis_func_floor **floor_func;
  54.   vorbis_func_residue **residue_func;
  55.  
  56.   int ch;
  57.   long lastframe; /* if a different mode is called, we need to 
  58.              invalidate decay */
  59. } vorbis_look_mapping0;
  60.  
  61. static vorbis_info_mapping *mapping0_copy_info(vorbis_info_mapping *vm){
  62.   vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)vm;
  63.   vorbis_info_mapping0 *ret=_ogg_malloc(sizeof(*ret));
  64.   memcpy(ret,info,sizeof(*ret));
  65.   return(ret);
  66. }
  67.  
  68. static void mapping0_free_info(vorbis_info_mapping *i){
  69.   vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)i;
  70.   if(info){
  71.     memset(info,0,sizeof(*info));
  72.     _ogg_free(info);
  73.   }
  74. }
  75.  
  76. static void mapping0_free_look(vorbis_look_mapping *look){
  77.   int i;
  78.   vorbis_look_mapping0 *l=(vorbis_look_mapping0 *)look;
  79.   if(l){
  80.     drft_clear(&l->fft_look);
  81.  
  82.     for(i=0;i<l->map->submaps;i++){
  83.       l->time_func[i]->free_look(l->time_look[i]);
  84.       l->floor_func[i]->free_look(l->floor_look[i]);
  85.       l->residue_func[i]->free_look(l->residue_look[i]);
  86.     }
  87.     if(l->psy_look[1] && l->psy_look[1]!=l->psy_look[0]){
  88.       _vp_psy_clear(l->psy_look[1]);
  89.       _ogg_free(l->psy_look[1]);
  90.     }
  91.     if(l->psy_look[0]){
  92.       _vp_psy_clear(l->psy_look[0]);
  93.       _ogg_free(l->psy_look[0]);
  94.     }
  95.     _ogg_free(l->time_func);
  96.     _ogg_free(l->floor_func);
  97.     _ogg_free(l->residue_func);
  98.     _ogg_free(l->time_look);
  99.     _ogg_free(l->floor_look);
  100.     _ogg_free(l->residue_look);
  101.     memset(l,0,sizeof(*l));
  102.     _ogg_free(l);
  103.   }
  104. }
  105.  
  106. static vorbis_look_mapping *mapping0_look(vorbis_dsp_state *vd,vorbis_info_mode *vm,
  107.               vorbis_info_mapping *m){
  108.   int i;
  109.   vorbis_info          *vi=vd->vi;
  110.   codec_setup_info     *ci=vi->codec_setup;
  111.   vorbis_look_mapping0 *look=_ogg_calloc(1,sizeof(*look));
  112.   vorbis_info_mapping0 *info=look->map=(vorbis_info_mapping0 *)m;
  113.   look->mode=vm;
  114.   
  115.   look->time_look=_ogg_calloc(info->submaps,sizeof(*look->time_look));
  116.   look->floor_look=_ogg_calloc(info->submaps,sizeof(*look->floor_look));
  117.  
  118.   look->residue_look=_ogg_calloc(info->submaps,sizeof(*look->residue_look));
  119.  
  120.   look->time_func=_ogg_calloc(info->submaps,sizeof(*look->time_func));
  121.   look->floor_func=_ogg_calloc(info->submaps,sizeof(*look->floor_func));
  122.   look->residue_func=_ogg_calloc(info->submaps,sizeof(*look->residue_func));
  123.   
  124.   for(i=0;i<info->submaps;i++){
  125.     int timenum=info->timesubmap[i];
  126.     int floornum=info->floorsubmap[i];
  127.     int resnum=info->residuesubmap[i];
  128.  
  129.     look->time_func[i]=_time_P[ci->time_type[timenum]];
  130.     look->time_look[i]=look->time_func[i]->
  131.       look(vd,vm,ci->time_param[timenum]);
  132.     look->floor_func[i]=_floor_P[ci->floor_type[floornum]];
  133.     look->floor_look[i]=look->floor_func[i]->
  134.       look(vd,vm,ci->floor_param[floornum]);
  135.     look->residue_func[i]=_residue_P[ci->residue_type[resnum]];
  136.     look->residue_look[i]=look->residue_func[i]->
  137.       look(vd,vm,ci->residue_param[resnum]);
  138.     
  139.   }
  140.   if(ci->psys && vd->analysisp){
  141.     if(info->psy[0] != info->psy[1]){
  142.  
  143.       int psynum=info->psy[0];
  144.       look->psy_look[0]=_ogg_calloc(1,sizeof(*look->psy_look[0]));      
  145.       _vp_psy_init(look->psy_look[0],ci->psy_param[psynum],
  146.            &ci->psy_g_param,
  147.            ci->blocksizes[vm->blockflag]/2,vi->rate);
  148.  
  149.       psynum=info->psy[1];
  150.       look->psy_look[1]=_ogg_calloc(1,sizeof(*look->psy_look[1]));      
  151.       _vp_psy_init(look->psy_look[1],ci->psy_param[psynum],
  152.            &ci->psy_g_param,
  153.            ci->blocksizes[vm->blockflag]/2,vi->rate);
  154.     }else{
  155.  
  156.       int psynum=info->psy[0];
  157.       look->psy_look[0]=_ogg_calloc(1,sizeof(*look->psy_look[0]));      
  158.       look->psy_look[1]=look->psy_look[0];
  159.       _vp_psy_init(look->psy_look[0],ci->psy_param[psynum],
  160.            &ci->psy_g_param,
  161.            ci->blocksizes[vm->blockflag]/2,vi->rate);
  162.  
  163.     }
  164.   }
  165.  
  166.   look->ch=vi->channels;
  167.  
  168.   if(vd->analysisp)drft_init(&look->fft_look,ci->blocksizes[vm->blockflag]);
  169.   return(look);
  170. }
  171.  
  172. static int ilog2(unsigned int v){
  173.   int ret=0;
  174.   while(v>1){
  175.     ret++;
  176.     v>>=1;
  177.   }
  178.   return(ret);
  179. }
  180.  
  181. static void mapping0_pack(vorbis_info *vi,vorbis_info_mapping *vm,
  182.               oggpack_buffer *opb){
  183.   int i;
  184.   vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)vm;
  185.  
  186.   /* another 'we meant to do it this way' hack...  up to beta 4, we
  187.      packed 4 binary zeros here to signify one submapping in use.  We
  188.      now redefine that to mean four bitflags that indicate use of
  189.      deeper features; bit0:submappings, bit1:coupling,
  190.      bit2,3:reserved. This is backward compatable with all actual uses
  191.      of the beta code. */
  192.  
  193.   if(info->submaps>1){
  194.     oggpack_write(opb,1,1);
  195.     oggpack_write(opb,info->submaps-1,4);
  196.   }else
  197.     oggpack_write(opb,0,1);
  198.  
  199.   if(info->coupling_steps>0){
  200.     oggpack_write(opb,1,1);
  201.     oggpack_write(opb,info->coupling_steps-1,8);
  202.     
  203.     for(i=0;i<info->coupling_steps;i++){
  204.       oggpack_write(opb,info->coupling_mag[i],ilog2(vi->channels));
  205.       oggpack_write(opb,info->coupling_ang[i],ilog2(vi->channels));
  206.     }
  207.   }else
  208.     oggpack_write(opb,0,1);
  209.   
  210.   oggpack_write(opb,0,2); /* 2,3:reserved */
  211.  
  212.   /* we don't write the channel submappings if we only have one... */
  213.   if(info->submaps>1){
  214.     for(i=0;i<vi->channels;i++)
  215.       oggpack_write(opb,info->chmuxlist[i],4);
  216.   }
  217.   for(i=0;i<info->submaps;i++){
  218.     oggpack_write(opb,info->timesubmap[i],8);
  219.     oggpack_write(opb,info->floorsubmap[i],8);
  220.     oggpack_write(opb,info->residuesubmap[i],8);
  221.   }
  222. }
  223.  
  224. /* also responsible for range checking */
  225. static vorbis_info_mapping *mapping0_unpack(vorbis_info *vi,oggpack_buffer *opb){
  226.   int i;
  227.   vorbis_info_mapping0 *info=_ogg_calloc(1,sizeof(*info));
  228.   codec_setup_info     *ci=vi->codec_setup;
  229.   memset(info,0,sizeof(*info));
  230.  
  231.   if(oggpack_read(opb,1))
  232.     info->submaps=oggpack_read(opb,4)+1;
  233.   else
  234.     info->submaps=1;
  235.  
  236.   if(oggpack_read(opb,1)){
  237.     info->coupling_steps=oggpack_read(opb,8)+1;
  238.  
  239.     for(i=0;i<info->coupling_steps;i++){
  240.       int testM=info->coupling_mag[i]=oggpack_read(opb,ilog2(vi->channels));
  241.       int testA=info->coupling_ang[i]=oggpack_read(opb,ilog2(vi->channels));
  242.  
  243.       if(testM<0 || 
  244.      testA<0 || 
  245.      testM==testA || 
  246.      testM>=vi->channels ||
  247.      testA>=vi->channels) goto err_out;
  248.     }
  249.  
  250.   }
  251.  
  252.   if(oggpack_read(opb,2)>0)goto err_out; /* 2,3:reserved */
  253.     
  254.   if(info->submaps>1){
  255.     for(i=0;i<vi->channels;i++){
  256.       info->chmuxlist[i]=oggpack_read(opb,4);
  257.       if(info->chmuxlist[i]>=info->submaps)goto err_out;
  258.     }
  259.   }
  260.   for(i=0;i<info->submaps;i++){
  261.     info->timesubmap[i]=oggpack_read(opb,8);
  262.     if(info->timesubmap[i]>=ci->times)goto err_out;
  263.     info->floorsubmap[i]=oggpack_read(opb,8);
  264.     if(info->floorsubmap[i]>=ci->floors)goto err_out;
  265.     info->residuesubmap[i]=oggpack_read(opb,8);
  266.     if(info->residuesubmap[i]>=ci->residues)goto err_out;
  267.   }
  268.  
  269.   return info;
  270.  
  271.  err_out:
  272.   mapping0_free_info(info);
  273.   return(NULL);
  274. }
  275.  
  276. #include "os.h"
  277. #include "lpc.h"
  278. #include "lsp.h"
  279. #include "envelope.h"
  280. #include "mdct.h"
  281. #include "psy.h"
  282. #include "scales.h"
  283.  
  284. /* no time mapping implementation for now */
  285. static long seq=0;
  286. static int mapping0_forward(vorbis_block *vb,vorbis_look_mapping *l){
  287.   vorbis_dsp_state      *vd=vb->vd;
  288.   vorbis_info           *vi=vd->vi;
  289.   codec_setup_info      *ci=vi->codec_setup;
  290.   backend_lookup_state  *b=vb->vd->backend_state;
  291.   bitrate_manager_state *bm=&b->bms;
  292.   vorbis_look_mapping0  *look=(vorbis_look_mapping0 *)l;
  293.   vorbis_info_mapping0  *info=look->map;
  294.   vorbis_info_mode      *mode=look->mode;
  295.   vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
  296.   int                    n=vb->pcmend;
  297.   int i,j;
  298.   float *window=b->window[vb->W][vb->lW][vb->nW][mode->windowtype];
  299.   int   *nonzero=alloca(sizeof(*nonzero)*vi->channels);
  300.  
  301.   float *work=_vorbis_block_alloc(vb,n*sizeof(*work));
  302.  
  303.   float global_ampmax=vbi->ampmax;
  304.   float *local_ampmax=alloca(sizeof(*local_ampmax)*vi->channels);
  305.   int blocktype=vbi->blocktype;
  306.  
  307.   /* we differentiate between short and long block types to help the
  308.      masking engine; the window shapes also matter.
  309.      impulse block (a short block in which an impulse occurs)
  310.      padding block (a short block that pads between a transitional 
  311.           long block and an impulse block, or vice versa)
  312.      transition block (the wqeird one; a long block with the transition 
  313.           window; affects bass/midrange response and that must be 
  314.       accounted for in masking) 
  315.      long block (run of the mill long block)
  316.   */
  317.  
  318.   for(i=0;i<vi->channels;i++){
  319.     float scale=4.f/n;
  320.     float scale_dB;
  321.  
  322.     /* the following makes things clearer to *me* anyway */
  323.     float *pcm     =vb->pcm[i]; 
  324.     float *fft     =work;
  325.     float *logfft  =pcm+n/2;
  326.  
  327.     /*float *res     =pcm;
  328.     float *mdct    =pcm;
  329.     float *codedflr=pcm+n/2;
  330.     float *logmax  =work;
  331.     float *logmask =work+n/2;*/
  332.  
  333.     scale_dB=todB(&scale);
  334.     _analysis_output("pcm",seq+i,pcm,n,0,0);
  335.  
  336.     /* window the PCM data */
  337.     for(j=0;j<n;j++)
  338.       fft[j]=pcm[j]*=window[j];
  339.     
  340.     /*_analysis_output("windowed",seq+i,pcm,n,0,0);*/
  341.  
  342.     /* transform the PCM data */
  343.     /* only MDCT right now.... */
  344.     mdct_forward(b->transform[vb->W][0],pcm,pcm);
  345.     
  346.     /* FFT yields more accurate tonal estimation (not phase sensitive) */
  347.     drft_forward(&look->fft_look,fft);
  348.     fft[0]*=scale;
  349.     logfft[0]=todB(fft);
  350.     local_ampmax[i]=logfft[0];
  351.     for(j=1;j<n-1;j+=2){
  352.       float temp=fft[j]*fft[j]+fft[j+1]*fft[j+1];
  353.       temp=logfft[(j+1)>>1]=scale_dB+.5f*todB(&temp);
  354.       if(temp>local_ampmax[i])local_ampmax[i]=temp;
  355.     }
  356.  
  357.     if(local_ampmax[i]>0.f)local_ampmax[i]=0.f;
  358.     if(local_ampmax[i]>global_ampmax)global_ampmax=local_ampmax[i];
  359.  
  360.     _analysis_output("fft",seq+i,logfft,n/2,1,0);
  361.   }
  362.  
  363.   for(i=0;i<vi->channels;i++){
  364.     int submap=info->chmuxlist[i];
  365.  
  366.     /* the following makes things clearer to *me* anyway */
  367.     float *mdct    =vb->pcm[i]; 
  368.     float *res     =mdct;
  369.     float *codedflr=mdct+n/2;
  370.     float *logfft  =mdct+n/2;
  371.  
  372.     float *logmdct =work;
  373.     float *logmax  =mdct+n/2;
  374.     float *logmask =work+n/2;
  375.  
  376.     for(j=0;j<n/2;j++)
  377.       logmdct[j]=todB(mdct+j);
  378.     _analysis_output("mdct",seq+i,logmdct,n/2,1,0);
  379.  
  380.  
  381.     /* perform psychoacoustics; do masking */
  382.     _vp_compute_mask(look->psy_look[blocktype],
  383.              logfft, /* -> logmax */
  384.              logmdct,
  385.              logmask,
  386.              global_ampmax,
  387.              local_ampmax[i],
  388.              bm->avgnoise);
  389.  
  390.     _analysis_output("mask",seq+i,logmask,n/2,1,0);
  391.     /* perform floor encoding */
  392.     nonzero[i]=look->floor_func[submap]->
  393.       forward(vb,look->floor_look[submap],
  394.           mdct,
  395.           logmdct,
  396.           logmask,
  397.           logmax,
  398.  
  399.           codedflr);
  400.  
  401.  
  402.     _vp_remove_floor(look->psy_look[blocktype],
  403.              mdct,
  404.              codedflr,
  405.              res);
  406.  
  407.     /*for(j=0;j<n/2;j++)
  408.       if(fabs(res[j])>1200){
  409.     analysis_noisy=1;
  410.     fprintf(stderr,"%ld ",seq+i);
  411.     }*/
  412.  
  413.     _analysis_output("codedflr",seq+i,codedflr,n/2,1,1);
  414.       
  415.   }
  416.  
  417.   vbi->ampmax=global_ampmax;
  418.  
  419.   /* partition based prequantization and channel coupling */
  420.   /* Steps in prequant and coupling:
  421.  
  422.      classify by |mag| across all pcm vectors 
  423.  
  424.      down-couple/down-quantize from perfect residue ->  quantized vector 
  425.      
  426.      do{ 
  427.         encode quantized vector; add encoded values to 'so-far' vector
  428.         more? [not yet at bitrate/not yet at target]
  429.           yes{
  430.               down-couple/down-quantize from perfect-'so-far' -> 
  431.             quantized vector; when subtracting coupling, 
  432.         account for +/- out-of-phase component
  433.           }no{  
  434.               break
  435.           }
  436.      }
  437.      done.
  438.  
  439.      quantization in each iteration is done (after circular normalization 
  440.      in coupling) using a by-iteration quantization granule value.
  441.   */
  442.    
  443.   {
  444.     float  **pcm=vb->pcm;
  445.     float  **quantized=alloca(sizeof(*quantized)*vi->channels);
  446.     float  **sofar=alloca(sizeof(*sofar)*vi->channels);
  447.  
  448.     long  ***classifications=alloca(sizeof(*classifications)*info->submaps);
  449.     float ***qbundle=alloca(sizeof(*qbundle)*info->submaps);
  450.     float ***pcmbundle=alloca(sizeof(*pcmbundle)*info->submaps);
  451.     float ***sobundle=alloca(sizeof(*sobundle)*info->submaps);
  452.     int    **zerobundle=alloca(sizeof(*zerobundle)*info->submaps);
  453.     int     *chbundle=alloca(sizeof(*chbundle)*info->submaps);
  454.     int      chcounter=0;
  455.  
  456.     /* play a little loose with this abstraction */
  457.     int   quant_passes=ci->coupling_passes;
  458.  
  459.     for(i=0;i<vi->channels;i++){
  460.       quantized[i]=_vorbis_block_alloc(vb,n*sizeof(*sofar[i]));
  461.       sofar[i]=quantized[i]+n/2;
  462.       memset(sofar[i],0,sizeof(*sofar[i])*n/2);
  463.     }
  464.  
  465.     qbundle[0]=alloca(sizeof(*qbundle[0])*vi->channels);
  466.     pcmbundle[0]=alloca(sizeof(*pcmbundle[0])*vi->channels);
  467.     sobundle[0]=alloca(sizeof(*sobundle[0])*vi->channels);
  468.     zerobundle[0]=alloca(sizeof(*zerobundle[0])*vi->channels);
  469.  
  470.     /* initial down-quantized coupling */
  471.     
  472.     if(info->coupling_steps==0){
  473.       /* this assumes all or nothing coupling right now.  it should pass
  474.      through any channels left uncoupled, but it doesn't do that now */
  475.       for(i=0;i<vi->channels;i++){
  476.     float *lpcm=pcm[i];
  477.     float *lqua=quantized[i];
  478.     for(j=0;j<n/2;j++)
  479.       lqua[j]=lpcm[j];
  480.       }
  481.     }else{
  482.       _vp_quantize_couple(look->psy_look[blocktype],
  483.               info,
  484.               pcm,
  485.               sofar,
  486.               quantized,
  487.               nonzero,
  488.               0);
  489.     }
  490.  
  491.     for(i=0;i<vi->channels;i++)
  492.       _analysis_output("quant",seq+i,quantized[i],n/2,1,0);
  493.  
  494.   
  495.     /* classify, by submap */
  496.  
  497.     for(i=0;i<info->submaps;i++){
  498.       int ch_in_bundle=0;
  499.       qbundle[i]=qbundle[0]+chcounter;
  500.       sobundle[i]=sobundle[0]+chcounter;
  501.       zerobundle[i]=zerobundle[0]+chcounter;
  502.  
  503.       for(j=0;j<vi->channels;j++){
  504.     if(info->chmuxlist[j]==i){
  505.       if(nonzero[j])
  506.         zerobundle[i][ch_in_bundle]=1;
  507.       else
  508.         zerobundle[i][ch_in_bundle]=0;
  509.       qbundle[i][ch_in_bundle]=quantized[j];
  510.       pcmbundle[i][ch_in_bundle]=pcm[j];
  511.       sobundle[i][ch_in_bundle++]=sofar[j];
  512.     }
  513.       }
  514.       chbundle[i]=ch_in_bundle;
  515.       chcounter+=ch_in_bundle;
  516.  
  517.       classifications[i]=look->residue_func[i]->
  518.     class(vb,look->residue_look[i],pcmbundle[i],zerobundle[i],chbundle[i]);
  519.     }
  520.  
  521.     /* actual encoding loop; we pack all the iterations to collect
  522.        management data */
  523.  
  524.     for(i=0;i<quant_passes;){
  525.  
  526.       /* perform residue encoding of this pass's quantized residue
  527.          vector, according residue mapping */
  528.     
  529.       for(j=0;j<info->submaps;j++){
  530.     look->residue_func[j]->
  531.       forward(vb,look->residue_look[j],
  532.           qbundle[j],sobundle[j],zerobundle[j],chbundle[j],
  533.           i,classifications[j],vbi->packet_markers);
  534.     
  535.       }
  536.       i++;
  537.     
  538.       if(i<quant_passes){
  539.     /* down-couple/down-quantize from perfect-'so-far' -> 
  540.      new quantized vector */
  541.     if(info->coupling_steps==0){
  542.       /* this assumes all or nothing coupling right now.  it should pass
  543.          through any channels left uncoupled, but it doesn't do that now */
  544.       int k;
  545.       for(k=0;k<vi->channels;k++){
  546.         float *lpcm=pcm[k];
  547.         float *lsof=sofar[k];
  548.         float *lqua=quantized[k];
  549.         for(j=0;j<n/2;j++)
  550.           lqua[j]=lpcm[j]-lsof[j];
  551.       }
  552.     }else{
  553.  
  554.       _vp_quantize_couple(look->psy_look[blocktype],
  555.                   info,
  556.                   pcm,
  557.                   sofar,
  558.                   quantized,
  559.                   nonzero,
  560.                   i);
  561.     }
  562.       }
  563.     }
  564.     seq+=vi->channels;
  565.   } 
  566.  
  567.   look->lastframe=vb->sequence;
  568.   return(0);
  569. }
  570.  
  571. static int mapping0_inverse(vorbis_block *vb,vorbis_look_mapping *l){
  572.   vorbis_dsp_state     *vd=vb->vd;
  573.   vorbis_info          *vi=vd->vi;
  574.   codec_setup_info     *ci=vi->codec_setup;
  575.   backend_lookup_state *b=vd->backend_state;
  576.   vorbis_look_mapping0 *look=(vorbis_look_mapping0 *)l;
  577.   vorbis_info_mapping0 *info=look->map;
  578.   vorbis_info_mode     *mode=look->mode;
  579.   int                   i,j;
  580.   long                  n=vb->pcmend=ci->blocksizes[vb->W];
  581.  
  582.   float *window=b->window[vb->W][vb->lW][vb->nW][mode->windowtype];
  583.   float **pcmbundle=alloca(sizeof(*pcmbundle)*vi->channels);
  584.   int    *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
  585.  
  586.   int   *nonzero  =alloca(sizeof(*nonzero)*vi->channels);
  587.   void **floormemo=alloca(sizeof(*floormemo)*vi->channels);
  588.   
  589.   /* time domain information decode (note that applying the
  590.      information would have to happen later; we'll probably add a
  591.      function entry to the harness for that later */
  592.   /* NOT IMPLEMENTED */
  593.  
  594.   /* recover the spectral envelope; store it in the PCM vector for now */
  595.   for(i=0;i<vi->channels;i++){
  596.     int submap=info->chmuxlist[i];
  597.     floormemo[i]=look->floor_func[submap]->
  598.       inverse1(vb,look->floor_look[submap]);
  599.     if(floormemo[i])
  600.       nonzero[i]=1;
  601.     else
  602.       nonzero[i]=0;      
  603.     memset(vb->pcm[i],0,sizeof(*vb->pcm[i])*n/2);
  604.   }
  605.  
  606.   /* channel coupling can 'dirty' the nonzero listing */
  607.   for(i=0;i<info->coupling_steps;i++){
  608.     if(nonzero[info->coupling_mag[i]] ||
  609.        nonzero[info->coupling_ang[i]]){
  610.       nonzero[info->coupling_mag[i]]=1; 
  611.       nonzero[info->coupling_ang[i]]=1; 
  612.     }
  613.   }
  614.  
  615.   /* recover the residue into our working vectors */
  616.   for(i=0;i<info->submaps;i++){
  617.     int ch_in_bundle=0;
  618.     for(j=0;j<vi->channels;j++){
  619.       if(info->chmuxlist[j]==i){
  620.     if(nonzero[j])
  621.       zerobundle[ch_in_bundle]=1;
  622.     else
  623.       zerobundle[ch_in_bundle]=0;
  624.     pcmbundle[ch_in_bundle++]=vb->pcm[j];
  625.       }
  626.     }
  627.     
  628.     look->residue_func[i]->inverse(vb,look->residue_look[i],
  629.                    pcmbundle,zerobundle,ch_in_bundle);
  630.   }
  631.  
  632.   /* channel coupling */
  633.   for(i=info->coupling_steps-1;i>=0;i--){
  634.     float *pcmM=vb->pcm[info->coupling_mag[i]];
  635.     float *pcmA=vb->pcm[info->coupling_ang[i]];
  636.  
  637.     for(j=0;j<n/2;j++){
  638.       float mag=pcmM[j];
  639.       float ang=pcmA[j];
  640.  
  641.       if(mag>0)
  642.     if(ang>0){
  643.       pcmM[j]=mag;
  644.       pcmA[j]=mag-ang;
  645.     }else{
  646.       pcmA[j]=mag;
  647.       pcmM[j]=mag+ang;
  648.     }
  649.       else
  650.     if(ang>0){
  651.       pcmM[j]=mag;
  652.       pcmA[j]=mag+ang;
  653.     }else{
  654.       pcmA[j]=mag;
  655.       pcmM[j]=mag-ang;
  656.     }
  657.     }
  658.   }
  659.  
  660.   /* compute and apply spectral envelope */
  661.   for(i=0;i<vi->channels;i++){
  662.     float *pcm=vb->pcm[i];
  663.     int submap=info->chmuxlist[i];
  664.     look->floor_func[submap]->
  665.       inverse2(vb,look->floor_look[submap],floormemo[i],pcm);
  666.   }
  667.  
  668.   /* transform the PCM data; takes PCM vector, vb; modifies PCM vector */
  669.   /* only MDCT right now.... */
  670.   for(i=0;i<vi->channels;i++){
  671.     float *pcm=vb->pcm[i];
  672.     mdct_backward(b->transform[vb->W][0],pcm,pcm);
  673.   }
  674.  
  675.   /* window the data */
  676.   for(i=0;i<vi->channels;i++){
  677.     float *pcm=vb->pcm[i];
  678.     if(nonzero[i])
  679.       for(j=0;j<n;j++)
  680.     pcm[j]*=window[j];
  681.     else
  682.       for(j=0;j<n;j++)
  683.     pcm[j]=0.f;
  684.  
  685.   }
  686.         
  687.   /* all done! */
  688.   return(0);
  689. }
  690.  
  691. /* export hooks */
  692. vorbis_func_mapping mapping0_exportbundle={
  693.   &mapping0_pack,
  694.   &mapping0_unpack,
  695.   &mapping0_look,
  696.   &mapping0_copy_info,
  697.   &mapping0_free_info,
  698.   &mapping0_free_look,
  699.   &mapping0_forward,
  700.   &mapping0_inverse
  701. };
  702.